package util;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Map;
import org.apache.log4j.Logger;

public class SimpleBeanConvertor {
    private static Logger logger = Logger.getLogger(SimpleBeanConvertor.class);

    /**
     * 将HTTP请求中的参数赋值给指定类型JavaBean的相关属性。
     *
     * @param request    HTTP请求
     * @param targetType 目标JavaBean类型
     * @return targetType类型的实例
     */
    public static <T> T convert(HttpServletRequest request, Class<T> targetType)
            throws IllegalAccessException, InstantiationException, ParseException, UnsupportedTypeException, InvocationTargetException {
        // 获取所有请求参数
        Map<String, String[]> params = request.getParameterMap();
        System.out.println("收到的参数: " + params); // 调试信息

        if (params.size() == 0) return null;
        T target = targetType.newInstance();
        Method[] allMethods = targetType.getMethods();
        if (allMethods != null && allMethods.length > 0) {
            for (Method method : allMethods) {
                if (method.getName().startsWith("set")) {
                    Class[] args = method.getParameterTypes();
                    if (args.length == 1) {
                        String paramName = method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4);
                        System.out.println("寻找参数: " + paramName + ", 类型: " + args[0]); // 调试信息

                        if (params.containsKey(paramName)) {
                            try {
                                Object value = parseValue(params.get(paramName), args[0]);
                                System.out.println("转换值: " + value + " -> " + args[0]); // 调试信息
                                method.invoke(target, value);
                            } catch (ParseException e) {
                                logger.debug("参数转换错误", e);
                                e.printStackTrace();
                                throw e;
                            }
                        } else if (Boolean.class == args[0] || boolean.class == args[0]) {
                            // 对于布尔类型，如果没有参数，默认设置为 false
                            System.out.println("设置默认布尔值: false"); // 调试信息
                            method.invoke(target, false);
                        }
                    }
                }
            }
        }
        return target;
    }

    private static Object parseValue(String[] value, Class type) throws ParseException, UnsupportedTypeException {
        System.out.println("解析值: " + value[0] + " -> " + type); // 调试信息

        if (String.class == type) return value[0];
        if (java.util.Date.class == type) return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(value[0]);

        // 修复布尔值处理
        if (boolean.class == type || Boolean.class == type) {
            return "true".equalsIgnoreCase(value[0]) || "on".equalsIgnoreCase(value[0]) || "1".equals(value[0]);
        }

        // 修复字符类型处理
        if (char.class == type || Character.class == type) {
            return value[0] != null && !value[0].isEmpty() ? value[0].charAt(0) : '\0';
        }

        // 修复整数类型处理
        if (int.class == type || Integer.class == type) {
            return Integer.valueOf(value[0]);
        }

        // 修复 Float 类型处理 - 单独处理
        if (float.class == type || Float.class == type) {
            return Float.valueOf(value[0]);
        }

        // 其他数值类型
        if (short.class == type || Short.class == type) {
            return Short.valueOf(value[0]);
        }
        if (long.class == type || Long.class == type) {
            return Long.valueOf(value[0]);
        }
        if (double.class == type || Double.class == type) {
            return Double.valueOf(value[0]);
        }

        // 其他包装类型
        if (type.getName().startsWith("java.lang.") || type.getName().startsWith("java.math.")) {
            try {
                return type.getConstructor(String.class).newInstance(value[0]);
            } catch (Exception e) {
                throw new UnsupportedTypeException(e);
            }
        }
        throw new UnsupportedTypeException();
    }
}